package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.ruoyi.common.annotation.DataScope;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.CxSelect;
import com.ruoyi.common.core.domain.Ztree;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.EvtTypeMapper;
import com.ruoyi.system.domain.EvtType;
import com.ruoyi.system.service.IEvtTypeService;
import com.ruoyi.common.core.text.Convert;

/**
 * 事件类型Service业务层处理
 *
 * @author ruoyi
 * @date 2024-08-18
 */
@Service
public class EvtTypeServiceImpl implements IEvtTypeService {
    @Autowired
    private EvtTypeMapper evtTypeMapper;

    /**
     * 查询事件类型
     *
     * @param typeId 事件类型主键
     * @return 事件类型
     */
    @Override
    public EvtType selectEvtTypeByTypeId(Long typeId) {
        return evtTypeMapper.selectEvtTypeByTypeId(typeId);
    }

    /**
     * 查询事件类型列表
     *
     * @param evtType 事件类型
     * @return 事件类型
     */
    @Override
    public List<EvtType> selectEvtTypeList(EvtType evtType) {
        return evtTypeMapper.selectEvtTypeList(evtType);
    }

    /**
     * 新增事件类型
     *
     * @param evtType 事件类型
     * @return 结果
     */
    @Override
    public int insertEvtType(EvtType evtType) {
        evtType.setCreateTime(DateUtils.getNowDate());
        return evtTypeMapper.insertEvtType(evtType);
    }

    /**
     * 修改事件类型
     *
     * @param evtType 事件类型
     * @return 结果
     */
    @Override
    public int updateEvtType(EvtType evtType) {
        evtType.setUpdateTime(DateUtils.getNowDate());
        return evtTypeMapper.updateEvtType(evtType);
    }

    /**
     * 批量删除事件类型
     *
     * @param typeIds 需要删除的事件类型主键
     * @return 结果
     */
    @Override
    public int deleteEvtTypeByTypeIds(String typeIds) {
        return evtTypeMapper.deleteEvtTypeByTypeIds(Convert.toStrArray(typeIds));
    }

    /**
     * 删除事件类型信息
     *
     * @param typeId 事件类型主键
     * @return 结果
     */
    @Override
    public int deleteEvtTypeByTypeId(Long typeId) {
        return evtTypeMapper.deleteEvtTypeByTypeId(typeId);
    }

    @Override
    public List<Ztree> selectTypeTree(EvtType evtType) {
        List<EvtType> evtTypeList = evtTypeMapper.selectEvtTypeList(evtType);
        List<Ztree> ztrees = initZtree(evtTypeList);
        return ztrees;
    }

    public List<Ztree> initZtree(List<EvtType> evtTypeList) {
        return initZtree(evtTypeList, null);
    }

    /**
     * 对象转部门树
     *
     * @param evtTypeList     事件类型列表
     * @param roleEvtTypeList 角色已存在菜单列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<EvtType> evtTypeList, List<String> roleEvtTypeList) {
        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = StringUtils.isNotNull(roleEvtTypeList);
        for (EvtType evtType : evtTypeList) {
            if (UserConstants.EVT_TYPE_NORMAL == evtType.getStatus()) {
                Ztree ztree = new Ztree();
                ztree.setId(evtType.getTypeId());
                ztree.setpId(evtType.getParentId());
                ztree.setName(evtType.getTypeName());
                ztree.setTitle(evtType.getTypeName());
                if (isCheck) {
                    ztree.setChecked(roleEvtTypeList.contains(evtType.getTypeId() + evtType.getTypeName()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }

    @Override
    public List<CxSelect> selectCxSelect(EvtType evtType) {
        List<EvtType> evtTypeList = evtTypeMapper.selectEvtTypeList(evtType);
        List<CxSelect> cxSelects = initCxSelect(evtTypeList, 0l);
        return cxSelects;
    }

    private List<CxSelect> initCxSelect(List<EvtType> evtTypeList, long parentId) {
        List<CxSelect> cxSelects = new ArrayList<>();
        for (EvtType evtType : evtTypeList) {
            if (evtType.getParentId() == parentId) {
                CxSelect cxSelect = new CxSelect();
                cxSelect.setN(evtType.getTypeName());
                cxSelect.setV(evtType.getTypeId() + "");
                cxSelects.add(cxSelect);

                List<CxSelect> subCxSelect = initCxSelect(evtTypeList, evtType.getTypeId());
                if (subCxSelect != null && subCxSelect.size() > 0) {
                    cxSelect.setS(subCxSelect);
                }
            }
        }
        return cxSelects;
    }

    public List<Long> getOrAddByTypeNames(String typeName1, String typeName2, String typeName3) {
        List<Long> lst = new ArrayList<>();
        //typeName1
        EvtType evtTypeSp = new EvtType();
        evtTypeSp.setAncestors("0");
        evtTypeSp.setTypeName(typeName1);
        EvtType evtType1 = evtTypeMapper.selectEvtTypeByAncestorsAndName(evtTypeSp);
        if (evtType1 == null) {
            long orderNum = evtTypeMapper.getMaxSort() + 1;

            evtType1 = new EvtType();
            evtType1.setParentId(0l);
            evtType1.setAncestors("0");
            evtType1.setTypeName(typeName1);
            evtType1.setStatus(UserConstants.EVT_TYPE_NORMAL);
            evtType1.setOrderNum(orderNum);
            evtTypeMapper.insertEvtType(evtType1);
        }
        lst.add(evtType1.getTypeId());

        //typename2
        EvtType evtType2 = null;
        if (StringUtils.isNotEmpty(typeName2)) {
            evtTypeSp = new EvtType();
            evtTypeSp.setAncestors("0," + evtType1.getTypeId());
            evtTypeSp.setTypeName(typeName2);
            evtType2 = evtTypeMapper.selectEvtTypeByAncestorsAndName(evtTypeSp);
            if (evtType2 == null) {
                long orderNum = evtTypeMapper.getMaxSort() + 1;

                evtType2 = new EvtType();
                evtType2.setParentId(evtType1.getTypeId());
                evtType2.setAncestors("0," + evtType1.getTypeId());
                evtType2.setTypeName(typeName2);
                evtType2.setStatus(UserConstants.EVT_TYPE_NORMAL);
                evtType2.setOrderNum(orderNum);
                evtTypeMapper.insertEvtType(evtType2);
            }
            lst.add(evtType2.getTypeId());
        }

        //typename3
        if (StringUtils.isNotEmpty(typeName2) && StringUtils.isNotEmpty(typeName3)) {
            evtTypeSp = new EvtType();
            evtTypeSp.setAncestors("0," + evtType1.getTypeId() + "," + evtType2.getTypeId());
            evtTypeSp.setTypeName(typeName3);
            EvtType evtType3 = evtTypeMapper.selectEvtTypeByAncestorsAndName(evtTypeSp);
            if (evtType3 == null) {
                long orderNum = evtTypeMapper.getMaxSort() + 1;

                evtType3 = new EvtType();
                evtType3.setParentId(evtType2.getTypeId());
                evtType3.setAncestors("0," + evtType1.getTypeId() + "," + evtType2.getTypeId());
                evtType3.setTypeName(typeName3);
                evtType3.setStatus(UserConstants.EVT_TYPE_NORMAL);
                evtType3.setOrderNum(orderNum);
                evtTypeMapper.insertEvtType(evtType3);
            }
            lst.add(evtType3.getTypeId());
        }

        return lst;
    }
}
